// profile.ts

interface UserInfo {
  avatarUrl: string;
  nickName: string;
  _openid?: string;
  createTime?: number;
  _id?: string;
}

interface ImageItem {
  id: number;
  imageUrl: string;
  promptText: string;
  _id?: string;
  _openid?: string;
  createTime?: number;
}

Page({
  data: {
    isLoggedIn: false,
    userInfo: {
      avatarUrl: '',
      nickName: ''
    } as UserInfo,
    userImages: [] as ImageItem[],
    openid: '',
    loadingUserInfo: true,
    showDialog: false,
    newNickname: ''
  },

  onLoad() {
    // 初始化云环境
    this.initCloud();
  },

  onShow() {
    // 如果已登录，获取用户的图片
    if (this.data.isLoggedIn) {
      this.getUserImages();
    }
  },

  // 初始化云开发环境
  async initCloud() {
    try {
      // 初始化云环境
      if (!wx.cloud) {
        console.error('请使用 2.2.3 或以上的基础库以使用云能力');
        return;
      }
      
      wx.cloud.init({
        env: 'cloud1-1gphd2vt3783c2f9',
        traceUser: true,
      });
      
      // 检查本地存储中是否有用户登录记录
      const isLoggedIn = wx.getStorageSync('isLoggedIn');
      const userInfo = wx.getStorageSync('userInfo');
      
      if (isLoggedIn && userInfo && userInfo.avatarUrl && userInfo.nickName) {
        // 本地有登录记录，使用本地存储的数据先展示
        this.setData({
          isLoggedIn: true,
          userInfo,
          loadingUserInfo: false
        });
        
        // 获取用户图片
        this.getUserImages();
      }
      
      // 无论是否有本地记录，都检查云端登录状态
      this.checkLoginStatus();
      
    } catch (error) {
      console.error('初始化云环境失败', error);
      wx.showToast({
        title: '初始化云环境失败',
        icon: 'none'
      });
    }
  },

  // 检查登录状态
  async checkLoginStatus() {
    try {
      // 调用云函数获取用户openid
      const loginRes = await wx.cloud.callFunction({
        name: 'login'
      }) as any;
      
      if (loginRes.result && loginRes.result.openid) {
        const openid = loginRes.result.openid;
        this.setData({ openid });
        
        // 从数据库获取用户信息
        await this.getUserInfoFromCloud(openid);
      } else {
        this.setData({ loadingUserInfo: false });
        console.error('获取用户openid失败');
      }
    } catch (error) {
      this.setData({ loadingUserInfo: false });
      console.error('检查登录状态失败', error);
    }
  },
  
  // 从云数据库获取用户信息
  async getUserInfoFromCloud(openid: string) {
    try {
      const db = wx.cloud.database();
      const userRes = await db.collection('users').where({
        _openid: openid
      }).get();
      
      if (userRes.data && userRes.data.length > 0) {
        // 用户已存在，更新登录状态
        const userInfo = userRes.data[0] as UserInfo;
        this.setData({
          userInfo,
          isLoggedIn: true,
          loadingUserInfo: false
        });
        
        // 存储用户信息到本地
        wx.setStorageSync('userInfo', userInfo);
        wx.setStorageSync('isLoggedIn', true);
        
        // 获取用户的图片
        this.getUserImages();
      } else {
        // 用户不存在，状态为未登录
        this.setData({
          isLoggedIn: false,
          loadingUserInfo: false
        });

        // 尝试自动获取用户微信信息
        this.tryAutoGetUserInfo();
      }
    } catch (error) {
      this.setData({ loadingUserInfo: false });
      console.error('获取用户信息失败', error);
    }
  },

  // 尝试自动获取用户微信信息
  tryAutoGetUserInfo() {
    // 由于微信限制，需要用户主动点击按钮触发获取用户信息
    // 这里不进行自动获取，保留用户点击登录按钮的流程
    console.log('等待用户点击登录按钮获取微信信息');
  },

  // 点击登录按钮
  onLoginTap() {
    // 显示加载中提示
    wx.showLoading({
      title: '正在登录...',
    });
    
    // 获取用户个人信息
    wx.getUserProfile({
      desc: '用于完善会员资料',
      success: async (res) => {
        console.log('获取到微信用户信息', res.userInfo);
        const userInfo = res.userInfo;
        
        // 确保头像和昵称不为空
        if (!userInfo.avatarUrl || !userInfo.nickName) {
          wx.hideLoading();
          wx.showToast({
            title: '获取微信信息失败',
            icon: 'none'
          });
          return;
        }
        
        // 将用户信息保存到云数据库
        await this.saveUserInfoToCloud(userInfo);
        
        // 隐藏加载提示
        wx.hideLoading();
      },
      fail: (err) => {
        console.error('获取用户信息失败', err);
        wx.hideLoading();
        
        // 显示获取失败提示
        wx.showToast({
          title: '登录失败，请重试',
          icon: 'none'
        });
      }
    });
  },
  
  // 保存用户信息到云数据库
  async saveUserInfoToCloud(userInfo: UserInfo) {
    try {
      const db = wx.cloud.database();
      
      // 查询用户是否已存在
      const userRes = await db.collection('users').where({
        _openid: this.data.openid
      }).get();
      
      let result;
      
      if (userRes.data && userRes.data.length > 0) {
        // 用户已存在，更新用户信息
        result = await db.collection('users').doc(userRes.data[0]._id as string).update({
          data: {
            avatarUrl: userInfo.avatarUrl,
            nickName: userInfo.nickName,
            updateTime: Date.now()
          }
        });
      } else {
        // 用户不存在，添加新用户
        result = await db.collection('users').add({
          data: {
            avatarUrl: userInfo.avatarUrl,
            nickName: userInfo.nickName,
            createTime: Date.now(),
            updateTime: Date.now()
          }
        });
      }
      
      // 更新页面状态
      const savedUserInfo = {
        _openid: this.data.openid,
        avatarUrl: userInfo.avatarUrl,
        nickName: userInfo.nickName,
        createTime: Date.now()
      };
      
      this.setData({
        isLoggedIn: true,
        userInfo: savedUserInfo
      });
      
      // 存储到本地
      wx.setStorageSync('userInfo', savedUserInfo);
      wx.setStorageSync('isLoggedIn', true);
      
      // 获取用户图片
      this.getUserImages();
      
      // 显示登录成功提示
      wx.showToast({
        title: '登录成功',
        icon: 'success'
      });
      
    } catch (error) {
      console.error('保存用户信息失败', error);
      
      // 显示保存失败提示
      wx.showToast({
        title: '登录失败，请重试',
        icon: 'none'
      });
    }
  },

  // 获取用户的图片
  async getUserImages() {
    try {
      this.setData({
        userImages: [] // 清空当前图片列表
      });
      
      const db = wx.cloud.database();
      const imagesRes = await db.collection('images')
        .where({
          _openid: this.data.openid
        })
        .orderBy('createTime', 'desc')
        .get();
      
      if (imagesRes.data && imagesRes.data.length > 0) {
        // 使用从数据库获取的真实图片数据
        this.setData({
          userImages: imagesRes.data as ImageItem[]
        });
      } else {
        // 没有图片数据
        wx.showToast({
          title: '暂无创建的图片',
          icon: 'none',
          duration: 2000
        });
      }
    } catch (error) {
      console.error('获取用户图片失败', error);
      
      wx.showToast({
        title: '获取图片失败',
        icon: 'none',
        duration: 2000
      });
    }
  },

  // 点击图片卡片
  onImageTap(e: any) {
    const url = e.currentTarget.dataset.url;
    
    // 预览图片
    wx.previewImage({
      urls: this.data.userImages.map(item => item.imageUrl),
      current: url
    });
  },

  // 选择头像
  async onChooseAvatar(e: any) {
    const { avatarUrl } = e.detail;
    
    if (avatarUrl) {
      try {
        wx.showLoading({ title: '更新头像中...' });
        
        // 先更新本地显示
        this.setData({
          'userInfo.avatarUrl': avatarUrl
        });
        
        // 上传到云数据库
        await this.updateUserAvatar(avatarUrl);
        
        wx.hideLoading();
        wx.showToast({ title: '头像更新成功', icon: 'success' });
      } catch (error) {
        console.error('更新头像失败', error);
        wx.hideLoading();
        wx.showToast({ title: '头像更新失败', icon: 'none' });
      }
    }
  },
  
  // 更新用户头像到云数据库
  async updateUserAvatar(avatarUrl: string) {
    try {
      const db = wx.cloud.database();
      
      // 更新用户头像
      if (this.data.userInfo._id) {
        await db.collection('users').doc(this.data.userInfo._id as string).update({
          data: {
            avatarUrl,
            updateTime: Date.now()
          }
        });
        
        // 更新本地存储
        const userInfo = wx.getStorageSync('userInfo') || {};
        userInfo.avatarUrl = avatarUrl;
        wx.setStorageSync('userInfo', userInfo);
      }
    } catch (error) {
      console.error('更新用户头像失败', error);
      throw error;
    }
  },
  
  // 显示修改昵称对话框
  showNicknameDialog() {
    console.log('点击修改昵称按钮');
    
    // 使用微信原生的showModal显示输入框
    wx.showModal({
      title: '修改昵称',
      content: '请输入新昵称',
      editable: true, // 显示输入框
      placeholderText: '请输入新昵称',
      success: (res) => {
        if (res.confirm) {
          const newNickname = res.content; // 获取用户输入的内容
          console.log('新昵称:', newNickname);
          
          // 验证输入
          if (!newNickname || !newNickname.trim()) {
            wx.showToast({ 
              title: '昵称不能为空', 
              icon: 'none' 
            });
            return;
          }
          
          // 字符长度限制校验
          if (newNickname.length > 20) {
            wx.showToast({ 
              title: '昵称不能超过20个字符', 
              icon: 'none' 
            });
            return;
          }
          
          // 如果昵称没有变化，不做任何操作
          if (newNickname === this.data.userInfo.nickName) {
            return;
          }
          
          // 更新昵称
          this.updateNickname(newNickname);
        }
      }
    });
  },
  
  // 更新昵称
  async updateNickname(newNickname: string) {
    try {
      wx.showLoading({ title: '更新昵称中...' });
      
      // 先更新本地显示，提升用户体验
      this.setData({
        'userInfo.nickName': newNickname
      });
      
      // 更新到云数据库
      await this.updateUserNickname(newNickname);
      
      wx.hideLoading();
      wx.showToast({ 
        title: '昵称更新成功', 
        icon: 'success' 
      });
    } catch (error) {
      console.error('更新昵称失败', error);
      
      // 更新失败，恢复原昵称
      this.setData({
        'userInfo.nickName': this.data.userInfo.nickName
      });
      
      wx.hideLoading();
      wx.showToast({ 
        title: '昵称更新失败，请重试', 
        icon: 'none' 
      });
    }
  },
  
  // 更新用户昵称到云数据库
  async updateUserNickname(nickName: string) {
    if (!this.data.isLoggedIn || !this.data.userInfo._id) {
      throw new Error('用户未登录或用户ID不存在');
    }
    
    try {
      const db = wx.cloud.database();
      
      // 更新用户昵称到云数据库
      await db.collection('users').doc(this.data.userInfo._id as string).update({
        data: {
          nickName,
          updateTime: Date.now()
        }
      });
      
      // 同时更新本地存储
      const userInfo = wx.getStorageSync('userInfo') || {};
      userInfo.nickName = nickName;
      wx.setStorageSync('userInfo', userInfo);
      
      console.log('昵称更新成功:', nickName);
      return true;
    } catch (error) {
      console.error('更新用户昵称失败', error);
      throw error;
    }
  },
  
  // 退出登录
  onLogoutTap() {
    wx.showModal({
      title: '提示',
      content: '确定要退出登录吗？',
      success: (res) => {
        if (res.confirm) {
          // 清除登录状态
          this.setData({
            isLoggedIn: false,
            userInfo: {
              avatarUrl: '',
              nickName: ''
            },
            userImages: []
          });
          
          // 清除本地存储的登录信息
          wx.removeStorageSync('userInfo');
          wx.removeStorageSync('isLoggedIn');
          
          wx.showToast({
            title: '已退出登录',
            icon: 'success'
          });
        }
      }
    });
  }
}) 